BigDFT.PDoS module

This module offers a suite of tools for calculating and analyzing the projected density of states (PDoS) in molecular systems. It provides functionality to extract projection information from cubic and linear scaling PDoS calculations, and compute weights associated with each projection.

Examples: The module includes two example functions (_example_cubic and _example_linear) to demonstrate usage with cubic and linear scaling PDoS calculations, respectively.

cubic_projection_info(log)[source]

Extracts projection information from a cubic scaling Projected Density of States (PDoS) calculation, as performed in a BigDFT run.

This function processes the output log file from a cubic scaling BigDFT calculation to map each atom in the system to its projections, such as ‘s’, ‘px’, ‘py’, ‘pz’, etc. The function is designed to work with the specific structure of BigDFT log files, particularly extracting information from the ‘Mulliken Charge Population Analysis’ section.

Parameters

log (BigDFT.Logfiles.Logfile) – A BigDFT log file object, containing the results of a cubic scaling calculation with the pdos option on.

Returns

A nested dictionary where the first key is the atomic symbol, and the second key is the projection type. The value is a list of indices, each corresponding to a projection of that type for the atom. For example: {‘C’: {‘s’: [0], ‘px’: [1], ‘py’: [2], ‘pz’: [3]}}.

Return type

dict of dict of list

cubic_projection_weights(log, proj_info, log_dir='.')[source]

Calculates the weights associated with each projection from a cubic scaling Projected Density of States (PDoS) calculation.

This function interprets the PDoS data stored in a BigDFT log file to compute the weights of different atomic projections (e.g., ‘s’, ‘px’, ‘py’, ‘pz’) for each orbital. It utilizes the projection information obtained from cubic_projection_info and the PDoS data file (‘pdos.dat’).

Parameters
  • log (BigDFT.Logfiles.Logfile) – The BigDFT log file object from a cubic scaling PDoS calculation.

  • proj_info (dict) – A dictionary mapping atomic symbols to projection types and indices, as returned by cubic_projection_info. log_dir (str, optional): The directory where the BigDFT log file is located. Defaults to the current directory (“.”).

Returns

A list where each element corresponds to an orbital. Each element is a dict, mapping atomic types to another dict, which in turn maps projections to their weights. For example, if you want the weight of the first orbital for the ‘s’ projection of Carbon, it would be accessed as weights[0][‘C’][‘s’].

Return type

list of dict

compute_weight(evec, sks_evec, orb_idx, proj_idx)[source]

Computes the weight of a specific projection for a given orbital in the projected density of states (PDoS) calculation, typically used in the linear scaling mode.

This function calculates the contribution of a specified set of projections (identified by their indices) to a particular orbital, based on the eigenvectors of the system. The function allows for optional inclusion of the overlap matrix (s) and the density matrix (k) if you’re doing Mulliken analysis or projecting out virtuals, respectively.

Parameters
  • evec (numpy.array) – Array of eigenvectors, where each column represents an eigenvector of the system.

  • evec – Overlap * Density * Overlap * evec. Overlap allows you to do a Mulliken projection, and Density can be used to filter in energy. If you’re doing Lowdin, just use the density. If you don’t need to filter in energy, the identity matrix can be used for the density.

  • orb_idx (int) – Index of the orbital for which the weight is being computed.

  • proj_idx (list of int) – List of indices corresponding to the projections included in the weight calculation.

Returns

the calculated weight.

Return type

(float)

linear_projection_info(log, thresh=0.3)[source]

Analyze and categorize projection types for each atom in the system based on electrostatic multipole information from a given log file.

This function processes the electrostatic multipoles associated with atoms in a system and classifies each support function (such as ‘s’, ‘px’, ‘py’, ‘pz’, ‘dxy’, etc.) based on their multipole expansion.

Parameters
  • log (BigDFT.Logfiles.Logfile) – The log file object from a BigDFT run.

  • thresh (float) – the threshold used for determining the character of a multipole.

Returns

A nested dictionary where the first key is the atomic symbol, the second key is the projection type, and the value is a list of indices associated with that projection type for the given atom. Example: {‘H’: {‘s’: [0]}, ‘O’: {‘px’: [1], ‘py’: [2], ‘pz’: [3]’}}

Return type

dict of dict of list

Raises
  • ValueError – If the projection type cannot be determined for an atom

  • based on the heuristic criteria.

linear_projection_weights(evec, proj_info, s, k)[source]

Computes the weights associated with a set of projections for each eigenvalue in a linear scaling Projected Density of States (PDoS) calculation.

This function uses the eigenvectors and eigenvalues of a system, along with projection information (such as atomic symbols and projection types), to calculate the contribution of these projections to each eigenvalue.

The function allows for inclusion of the overlap matrix (s) and the density matrix (k) if you’re doing Mulliken analysis or projecting out virtuals, respectively. If you’re doing Lowdin, pass the Lowdin orthogonalized eigenvectors and the identity matrix for s. You’re doing Mulliken, and don’t want to project out virtuals, pass the overlap matrix as K.

Parameters
  • evec (numpy.array) – Array of eigenvectors, where each column represents an eigenvector of the system.

  • proj_info (dict) – Dictionary mapping atom symbols to projections, and projections to indices, as obtained from linear_projection_info.

  • s (numpy.array) – Overlap matrix, used in the calculation of the weights

  • k (numpy.array) – Density matrix, used in the calculation of the weights

Returns

A list where each element corresponds to an eigenvalue. Each element is a dict, mapping atomic types to another dict, which in turn maps projections to their computed weights. For example, weights[0][‘C’][‘s’] would access the weight of ‘s’ projection for Carbon for the first eigenvalue.

Return type

list of dict

compute_fragment_weights(sys, log, evec, evals, s, k)[source]

Computes the weights associated with fragments in a system for each eigenvalue for a Fragment Projected Density of States (PDoS) calculation.

Parameters
  • sys (BigDFT.Systems.System) – The system object as defined in BigDFT, representing the fragments of the system.

  • log (BigDFT.Logfiles.Logfile) – The log file object from a BigDFT run computed in the linear scaling mode.

  • evec (numpy.array) – Array of eigenvectors, where each column represents an eigenvector of the system.

  • s (numpy.array) – Overlap matrix, used in the calculation of the weights

  • k (numpy.array) – Density matrix, used in the calculation of the weights

Returns

A list where each element corresponds to an eigenvalue. Each element is a dict, mapping fragment identifiers to their computed weights. For example, weights[0][‘HOH:1’] accesses the weight of fragment ‘HOH:1’ for the first eigenvalue.

Return type

list of dict

_example_cubic()[source]

The following is an example of module usage:

# System
from BigDFT.Database.Molecules import get_molecule
sys = get_molecule("H2O")

# Input file
from BigDFT.Inputfiles import Inputfile
inp = Inputfile()
inp.set_hgrid(0.4)
inp.set_xc("PBE")
inp.calculate_pdos()

# Calculate
from BigDFT.Calculators import SystemCalculator
code = SystemCalculator(skip=True, verbose=False)
log = code.run(sys=sys, input=inp, name="pdos-C")

# Get weights
proj_list = cubic_projection_info(log)
weights = cubic_projection_weights(log, proj_list)

print(weights[0]["O"]["s"])
print(weights[1]["H"]["s"])
_example_linear()[source]

The following is an example of module usage:

# System
from BigDFT.Database.Molecules import get_molecule
sys = get_molecule("H2O")

# Input file
from BigDFT.Inputfiles import Inputfile
inp = Inputfile()
inp.set_hgrid(0.4)
inp.set_xc("PBE")
inp["import"] = "linear"
inp["lin_general"] = {"support_function_multipoles": True}

from BigDFT.Calculators import SystemCalculator
code = SystemCalculator(skip=True, verbose=False)
log = code.run(sys=sys, input=inp, name="pdos-L")

# Read the matrices
from BigDFT.PostProcessing import BigDFTool
tool = BigDFTool()
h = tool.get_matrix_h(log)
s = tool.get_matrix_s(log)
k = tool.get_matrix_k(log)

# Diagonalize
from scipy.linalg import eigh
evals, evec = eigh(h.todense(), b=s.todense())

# Get the weights
proj_info = linear_projection_info(log)
weights = linear_projection_weights(evec, proj_info, s=s, k=0.5 * k)
print(weights[0]["O"]["s"])
print(weights[1]["H"]["s"])